home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / ada / ada_lrm3.zip / LR7AVCB.SRC < prev    next >
Text File  |  1989-03-28  |  41KB  |  1,251 lines
  1.  
  2.  
  3. --                ON-LINE Ada LANGUAGE REFERENCE MANUAL
  4. --        Developed at Nofolk State University
  5. --        Development funded by a grant from the U. S. Army
  6. --        Project ReDTEA
  7. --        Version 1.0 released December 1988
  8. --        Programmer:        Esther M. Lumsdon
  9. --        Project Director:  George C. Harrison, PhD
  10.  
  11.  
  12.  
  13. package body LRM_NON_SMG is 
  14.  
  15.  
  16.  
  17.   procedure INITIALIZE is 
  18.   --    Initialization for on-line Ada Language Reference Manual
  19.   --
  20.   --
  21.   ----------------------------------------------------------------------------
  22.     procedure DECIDE_TERM_CATEGORY(USING_DEC_TERMINAL : out BOOLEAN) is 
  23.  
  24.       CHOSE_TERMINAL_CATEGORY : BOOLEAN; 
  25.       TERM_CATEGORY           : STRING(1 .. 5); 
  26.       TERM_CATEGORY_LENGTH    : NATURAL; 
  27.  
  28.  
  29.     begin
  30.  
  31.       loop
  32.         CLS; 
  33.         PUT_LINE("  The following terminals are available for your use at NSU:")
  34.           ; 
  35.         PUT_LINE("Category A terminals:"); 
  36.         PUT_LINE("    VISUAL brand terminals"); 
  37.         PUT_LINE("    TeleVideo brand terminals"); 
  38.         PUT_LINE("    DEC terminals"); 
  39.         NEW_LINE; 
  40.         PUT_LINE("Category B terminals:"); 
  41.         PUT_LINE("    ADM brand terminals"); 
  42.         PUT_LINE("    Adds-Viewpoint terminals"); 
  43.         PUT_LINE("    Hazeltine brand terminals"); 
  44.         NEW_LINE(2); 
  45.         PUT(
  46.           "Please enter A or B for the category of terminal that you are using: "
  47.           ); 
  48.         GET_LINE(TERM_CATEGORY, TERM_CATEGORY_LENGTH); 
  49.         CHOSE_TERMINAL_CATEGORY := TRUE; 
  50.         case TERM_CATEGORY(1) is 
  51.           when 'A' | ASCII.LC_A => 
  52.             USING_DEC_TERMINAL := TRUE; 
  53.           when 'B' | ASCII.LC_B => 
  54.             USING_DEC_TERMINAL := FALSE; 
  55.           when others => 
  56.             CHOSE_TERMINAL_CATEGORY := FALSE; 
  57.         end case; 
  58.         exit when CHOSE_TERMINAL_CATEGORY; 
  59.       end loop; 
  60.  
  61.     end DECIDE_TERM_CATEGORY; 
  62.  
  63.  
  64.  
  65.  
  66.   begin
  67.     USING_DEC_TERMINAL := FALSE; 
  68.   end INITIALIZE; 
  69.  
  70.  
  71.  
  72.  
  73. ------------------------------------------------------------------------------
  74.  
  75.  
  76.   procedure TERMINATE_LRM is 
  77.  
  78.   begin
  79.     if IS_OPEN(SAVE_FILE) then 
  80.       CLOSE(SAVE_FILE); 
  81.     end if; 
  82.     CLS; 
  83.     NEW_LINE(2); 
  84.     PUT_LINE("Thank you for using the Ada Language Reference Manual Reader."); 
  85.   end TERMINATE_LRM; 
  86.  
  87.  
  88. ------------------------------------------------------------------------------
  89.  
  90.   procedure DISPLAY_MAIN_MENU(IN_FILE_NAME : in STRING) is 
  91.  
  92.  
  93.  
  94.   -- read menu text from file, and put entire file on screen.
  95.  
  96.     EMPTY_STRING_80 : STRING(1 .. 80); 
  97.     LAST_CHAR       : NATURAL := 0; 
  98.     READ_IN_FILE    : FILE_TYPE; 
  99.     READ_IN_LINE    : STRING(1 .. 80); 
  100.  
  101.  
  102.   begin
  103.     EMPTY_STRING_80 := (others => ' '); 
  104.     if not USING_DEC_TERMINAL then 
  105.       OPEN(READ_IN_FILE, IN_FILE, IN_FILE_NAME); 
  106.       while not END_OF_FILE(READ_IN_FILE) loop
  107.         READ_IN_LINE := EMPTY_STRING_80; 
  108.         GET_LINE(READ_IN_FILE, READ_IN_LINE, LAST_CHAR); 
  109.         PUT_LINE(READ_IN_LINE(1 .. SCREEN_WIDTH)); 
  110.       end loop; 
  111.     end if; 
  112.  
  113.   end DISPLAY_MAIN_MENU; 
  114.  
  115.  
  116.  
  117.  
  118. ------------------------------------------------------------------------------
  119.  
  120.   procedure DISPLAY_MENU(IN_FILE_NAME : in STRING) is 
  121.  
  122.  
  123.  
  124.   -- read menu text from file, and put entire file on screen.
  125.  
  126.     EMPTY_STRING_80 : STRING(1 .. 80); 
  127.     LAST_CHAR       : NATURAL := 0; 
  128.     READ_IN_FILE    : FILE_TYPE; 
  129.     READ_IN_LINE    : STRING(1 .. 80); 
  130.  
  131.  
  132.   begin
  133.     EMPTY_STRING_80 := (others => ' '); 
  134.  
  135.     OPEN(READ_IN_FILE, IN_FILE, IN_FILE_NAME); 
  136.     while not END_OF_FILE(READ_IN_FILE) loop
  137.       READ_IN_LINE := EMPTY_STRING_80; 
  138.       GET_LINE(READ_IN_FILE, READ_IN_LINE, LAST_CHAR); 
  139.       PUT_LINE(READ_IN_LINE(1 .. SCREEN_WIDTH)); 
  140.     end loop; 
  141.  
  142.   end DISPLAY_MENU; 
  143.  
  144.  
  145.  
  146.  
  147.  
  148.   ---------------------------------------------------------------------------
  149.  
  150.   procedure SCROLL_TEXT(IN_FILE_NAME : in STRING; 
  151.                         SAVE_TITLE   : in STRING; 
  152.                         SAVE_FILE    : in out FILE_TYPE) is 
  153.  
  154.  
  155.   -- scroll text file on the screen, 19 lines at a time
  156.  
  157.     type COMMAND is (CONTINUE, DISPLAY_AGAIN, EXIT_COMMAND, SAVE, NOTHING); 
  158.  
  159.     BLANK_COUNT        : NATURAL := 0; 
  160.     CURRENT_LINE       : NATURAL := 0; 
  161.     CURSOR_CONTROL_STR : STRING(1 .. 7) := "       "; 
  162.     EXIT_NOW           : BOOLEAN := FALSE; 
  163.     GOOD_ANSWER        : BOOLEAN; 
  164.     LAST_CHAR          : NATURAL := 0; 
  165.     LAST_COMMAND       : COMMAND := NOTHING; 
  166.     READ_IN_FILE       : FILE_TYPE; 
  167.     READ_IN_LINE       : STRING(1 .. 80); 
  168.     EMPTY_STRING_80    : STRING(1 .. 80); 
  169.     SAVING             : BOOLEAN := FALSE; 
  170.     TARGET_LINE        : NATURAL; 
  171.     WAIT_STR           : STRING(1 .. 10); 
  172.     WAIT_STR_LENGTH    : NATURAL; 
  173.     LINE_COUNT         : NATURAL := 0; 
  174.  
  175.   begin
  176.     EMPTY_STRING_80 := (others => ' '); 
  177.     OPEN(READ_IN_FILE, IN_FILE, IN_FILE_NAME); 
  178.  
  179.     while not EXIT_NOW loop
  180.       LINE_COUNT := 0; 
  181.       if LAST_COMMAND /= SAVE then 
  182.  
  183.         while ((not END_OF_FILE(READ_IN_FILE)) and (LINE_COUNT < (SCREEN_HEIGHT
  184.           - 3))) loop
  185.           if LINE_COUNT = 0 then 
  186.             CLS; 
  187.           end if; 
  188.           READ_IN_LINE := EMPTY_STRING_80; 
  189.           GET_LINE(READ_IN_FILE, READ_IN_LINE, LAST_CHAR); 
  190.           if LAST_CHAR = 0 then 
  191.             BLANK_COUNT := BLANK_COUNT + 1; 
  192.           else 
  193.             BLANK_COUNT := 0; 
  194.           end if; 
  195.           if BLANK_COUNT < 3 then 
  196.             if LAST_CHAR > (SCREEN_WIDTH) then 
  197.               PUT_LINE(READ_IN_LINE(1 .. SCREEN_WIDTH)); 
  198.               PUT_LINE(READ_IN_LINE(SCREEN_WIDTH + 1 .. LAST_CHAR)); 
  199.               LINE_COUNT := LINE_COUNT + 2; 
  200.             else 
  201.               PUT_LINE(READ_IN_LINE(1 .. SCREEN_WIDTH)); 
  202.               LINE_COUNT := LINE_COUNT + 1; 
  203.             end if; 
  204.           end if; 
  205.           if SAVING then 
  206.             PUT_LINE(SAVE_FILE, READ_IN_LINE(1 .. LAST_CHAR)); 
  207.           end if; 
  208.           CURRENT_LINE := CURRENT_LINE + 1; 
  209.         end loop; 
  210.  
  211.       end if; 
  212.  
  213.       GOOD_ANSWER := FALSE; 
  214.       while not GOOD_ANSWER loop
  215.         GOOD_ANSWER := TRUE; 
  216.         if LINE < 21 then 
  217.           CURSOR_CONTROL_STR(2 .. 4) := INTEGER'IMAGE(SCREEN_HEIGHT); 
  218.           CURSOR_CONTROL_STR(2) := '['; 
  219.           CURSOR_CONTROL_STR(5 .. 7) := ";1H"; 
  220.           CURSOR_CONTROL_STR(1) := ASCII.ESC; 
  221.           PUT_LINE(CURSOR_CONTROL_STR); 
  222.  
  223.         -- cursor_control_str contains ASCII.ESC & "[nn;1H"
  224.         end if; 
  225.  
  226.         -- put cursor on line screen_height of screen
  227.         WAIT_STR(1) := 'c'; 
  228.         if END_OF_FILE(READ_IN_FILE) then 
  229.           PUT("     E[xit]   S[ave]   D[isplay again] "); 
  230.           GET_LINE(WAIT_STR, WAIT_STR_LENGTH); 
  231.         else 
  232.           PUT("     E[xit]   C[ontinue]   S[ave]   D[isplay again] "); 
  233.           GET_LINE(WAIT_STR, WAIT_STR_LENGTH); 
  234.         end if; 
  235.         case WAIT_STR(1) is 
  236.           when 'E' | ASCII.LC_E => 
  237.             LAST_COMMAND := EXIT_COMMAND; 
  238.             EXIT_NOW := TRUE; 
  239.             exit; 
  240.           when 'S' | ASCII.LC_S => 
  241.             LAST_COMMAND := SAVE; 
  242.             if not SAVING then 
  243.               if not IS_OPEN(SAVE_FILE) then 
  244.                 CREATE(SAVE_FILE, OUT_FILE, LRM_READER_SAVE_FILE_NAME); 
  245.               end if; 
  246.               PUT_LINE(SAVE_FILE, 
  247.                 "Reference from Ada Language Reference Manual:"); 
  248.               PUT_LINE(SAVE_FILE, SAVE_TITLE); 
  249.  
  250.               -- write title of what is being saved to save_file.
  251.               NEW_LINE(SAVE_FILE, 2); 
  252.               SAVING := TRUE; 
  253.               if CURRENT_LINE > 1 then 
  254.                 RESET(READ_IN_FILE, IN_FILE); 
  255.                 for I in 1 .. CURRENT_LINE loop
  256.                   GET_LINE(READ_IN_FILE, READ_IN_LINE, LAST_CHAR); 
  257.                   PUT_LINE(SAVE_FILE, READ_IN_LINE(1 .. LAST_CHAR)); 
  258.                 end loop; 
  259.               end if; 
  260.             end if; 
  261.           when 'D' | ASCII.LC_D => 
  262.             LAST_COMMAND := DISPLAY_AGAIN; 
  263.             RESET(READ_IN_FILE, IN_FILE); 
  264.             CURRENT_LINE := 0; 
  265.           when '